// 题目描述
// 给两个整数 n, m;  n 表示 迷宫的行，m 表示迷宫的列；
// 给 n 个字符串，字符串由 * . 和 e 组成，
// * 表示障碍，不可逾越
// . 表示通道，可以正常通行
// e 表示出口
// 只能上下左右 4 个方向移动，求能到达几个出口，最近出口的距离是多少？
// 没有出口输出 -1

// 解题思路：
// 经典的 bfs 问题，注意题目要求既要找到能到达的出口的个数，又要找到最近出口的距离，
// 因此可以使用一个 distance 二维数组，表示从起点到达某个坐标的距离
// bfs 的过程中将数组填好
// 遍历 distance 数组，就能找到出口的个数以及最近出口的距离


import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Maze{
    public static int n;
    public static int m;
    public static char[][] grid;
    public static int[][] distance;
    public static int[] start = new int[2];
    public static int[] dx = {0, 0, 1, -1};
    public static int[] dy = {1, -1, 0, 0};

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

        n = in.nextInt();
        m = in.nextInt();

        grid = new char[n][m];
        distance = new int[n][m];
        for(int i = 0; i < n; i++){
            Arrays.fill(distance[i], -1);
        }

        for(int i = 0; i < n; i++){
            grid[i] = in.next().toCharArray();
            for(int j = 0; j < m; j++){
                if(grid[i][j] == 'k'){
                    start[0] = i;
                    start[1] = j;
                }
            }
        }

        bfs();

        int count = 0;
        int ret = Integer.MAX_VALUE;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == 'e' && distance[i][j] != -1){
                    count++;
                    ret = Math.min(ret, distance[i][j]);
                }
            }
        }

        if(count == 0){
            System.out.println(-1);
        }else{
            System.out.println(count + " " + ret);
        }
    }

    public static void bfs(){
        Queue<int[]> queue = new LinkedList<>();

        queue.offer(start);
        distance[start[0]][start[1]] = 0;

        while(!queue.isEmpty()){
            int[] point = queue.poll();
            int a = point[0]; int b = point[1];
            for(int i = 0; i < 4; i++){
                int x = a + dx[i];
                int y = b + dy[i];

                if(x >= 0 && x < n && y >= 0 && y < m && grid[x][y] != '*' && distance[x][y] == -1){
                    distance[x][y] = distance[a][b] + 1;
                    if(grid[x][y] != 'e'){
                        queue.offer(new int[] {x, y});
                    }
                }
            }
        }
    }
}
